package edu.upn.sigemfi.plt.beans;

import java.util.Date;
import java.util.List;
import javax.faces.model.SelectItem;
import java.util.ArrayList;
import edu.upn.sigemfi.plt.be.Cuenta;
import edu.upn.sigemfi.plt.be.DetalleCuentaCliente;
import edu.upn.sigemfi.plt.be.DetalleCuentaClientePK;
import edu.upn.sigemfi.plt.bc.DetalleCuentaClienteDelegate;
import edu.upn.sigemfi.plt.bc.CuentaDelegate;
import edu.upn.sigemfi.plt.be.EstadoCuenta;
import edu.upn.sigemfi.plt.be.EstadoDetalleCuenta;
import edu.upn.sigemfi.plt.be.ModalidadAfiliacion;
import edu.upn.sigemfi.plt.beans.CuentaController;
import edu.upn.sigemfi.seg.be.Persona;
import edu.upn.sigemfi.seg.be.PersonaNatural;
import edu.upn.sigemfi.seg.be.PersonaJuridica;
import edu.upn.sigemfi.seg.beans.AbstractController;
import java.util.AbstractList;

public class AsosiacionCuentaClienteController extends AbstractController {

    private Cuenta cuenta;
    //   private ModalidadAfiliacion modalidadAfiliacion;
    private Persona personaTemp;
    private DetalleCuentaCliente detalleCuentaCliente;
    private PersonaNatural personaNaturalTemp;
    private PersonaJuridica personaJuridicaTemp;
    // private PersonaJuridica personaJuridica;
    private DetalleCuentaClienteDelegate detalleCuentaClienteDelegado;
    private CuentaDelegate cuentaDelegado;
    private DetalleCuentaClientePK detalleCuentaClientePK;
    //private EstadoDetalleCuenta estadoDetalleCuenta ;
    public boolean bolAgregarPersonaNatural;
    public boolean bolAgregarPersonaJuridica;
    private boolean bolAgregarCliente;
    private boolean esClienteNatural;
    private boolean bolInicioTablaAgregarPersonas;
    public boolean bolEditarMancomunados;
    private List<PersonaNatural> personasNaturalesAgregar;
    private List<PersonaNatural> nuevosMancomunadosAgregar;
    //private List<PersonaNatural> listaPersonas;
    private List<PersonaJuridica> personasJuridicasAgregar;
    private CuentaController cuentaControllerTemp;
    //private Date fechaActual;
    //private String modalidadCuenta;

    public AsosiacionCuentaClienteController() {
        //      cuentaDelegado = new CuentaDelegate();
        //modalidadAfiliacion = ModalidadAfiliacion.Individual;//por defecto todas son modalidad individual
        detalleCuentaClienteDelegado = new DetalleCuentaClienteDelegate();
        cuentaDelegado = new CuentaDelegate();
        detalleCuentaCliente = new DetalleCuentaCliente();
        cuenta = new Cuenta();//cuando se llame a este controller la cuenta puede ser seteada
        detalleCuentaClientePK = new DetalleCuentaClientePK();
//        bolAgregarPersonaJuridica = true;//para controlar la opcion de agregar persona JURIDICA
//        bolAgregarPersonaNatural = true;//para controlar la opcion de agregar persona NATURAL
        bolAgregarCliente = false; //para tener la opcion de "Agregar Cliente" en la pagina "Listar Cliente"
        bolInicioTablaAgregarPersonas = false;
        bolEditarMancomunados = false;
        personasJuridicasAgregar = new ArrayList<PersonaJuridica>();
        personasNaturalesAgregar = new ArrayList<PersonaNatural>();
        nuevosMancomunadosAgregar = null;
        personaJuridicaTemp = new PersonaJuridica();
        personaNaturalTemp = new PersonaNatural();
    }

    public String CancelarRetiroCliente() {
        bolAgregarPersonaNatural = false;//volvemos al estado inicial, solo para el UC:EDITAR MANCOMUNADOS
        return "clienteRetirado";
    }

    public String ClienteARetirar() {
        bolAgregarPersonaNatural = true;//para mostrar los datos del cliente natural en el UC:EDITAR MANCOMUNADOS
        return "clienteARetirar";
    }

    public String ClienteNaturalRetirado() {
        if (personasNaturalesAgregar.size() == 0) {
            info("No se encontro Clientes Naturales previos");
        } else {
            personasNaturalesAgregar.remove(personaNaturalTemp);
            //personasNaturalesAgregar.remove(personaNaturalTemp);
            // personaNaturalTemp = new PersonaNatural();//liberamos la personaNatural para poder eliminar otra
        }
        if (bolEditarMancomunados == true) {
            bolAgregarPersonaNatural = false;//para no mostra opciones disponibles, en el UC:EDITARMANCOMUNADOS
        }
        bolAgregarPersonaNatural = true;
        return "clienteRetirado";
    }

    public String ClienteJuridicoRetirado() {
        if (personasJuridicasAgregar == null) {
            info("No se encontro un Cliente Juridico previo");
        } else {
            personasJuridicasAgregar.remove(personaJuridicaTemp);
            personaJuridicaTemp = new PersonaJuridica();//liberamos la personaNatural para poder eliminar otra
        }
        return "clienteRetirado";
    }

//---------------------PARA AGREGAR Y QUITAR LAS PERSONAS DEL ARREGLO
    public String AsociarPersonaNatural() {

        for (PersonaNatural pn : personasNaturalesAgregar) {
            if (pn.getIdPersona() == personaNaturalTemp.getIdPersona()) {
                error("No Puedes agregar a la misma persona");
                return "clienteAsociado";
            }
        }
        personasNaturalesAgregar.add(personaNaturalTemp);
        bolAgregarPersonaJuridica = false;//no me salgan las opciones de Aceptar y Cancelar de Cliente Juridico
        //   }
        bolInicioTablaAgregarPersonas = true;
        return "clienteAsociado";
    }

    public String agregarNuevoMancomunado() {

        for (PersonaNatural pn1 : personasNaturalesAgregar) {
            if (pn1.getDniPersona() == personaNaturalTemp.getDniPersona()) {
                error("No Puedes agregar a la misma persona");
                return "clienteAsociado";
            }
        }

        for (PersonaNatural pn : nuevosMancomunadosAgregar) {
            if (pn.getIdPersona() == personaNaturalTemp.getIdPersona()) {
                error("No Puedes agregar a la misma persona");
                return "clienteAsociado";
            }
        }
        nuevosMancomunadosAgregar.add(personaNaturalTemp);
        //   }
        bolEditarMancomunados = true; //para que sea activen la lista de nuevos mancomunados
        return "clienteAsociado";
    }

    public String AsociarPersonaJuridica() {
        if (personasJuridicasAgregar == null || personaJuridicaTemp == null) {
            personasJuridicasAgregar = new ArrayList<PersonaJuridica>();
            personaJuridicaTemp = new PersonaJuridica();
        } else {
            for (PersonaJuridica pj : personasJuridicasAgregar) {
                if (pj.getIdPersona() == personaJuridicaTemp.getIdPersona()) {
                    error("No Puedes agregar la misma Juridica");
                    return "clienteAsociado";
                } else if (personasJuridicasAgregar.size() >= 1) { //ya existe un cliente juridico agregado
                    error("No se puede agregar otra persona Juridica");
                    return "clienteAsociado";
                }

            }
            personasJuridicasAgregar.add(personaJuridicaTemp);
        }
        bolInicioTablaAgregarPersonas = true;
        bolAgregarPersonaNatural = false;//no se me salgan las opciones de Aceptar y Cancelar de Cliente Natural
        return "clienteAsociado";
    }

//----------------------------------------------------------------------
    public String Cancelar() {
        reiniciarEstados();
        return "cuentaAsociada";
    }

//    public String AsociarCliente() {
//        bolAgregarCliente = true;
//        personaNaturalTemp = new PersonaNatural();
//        personaJuridicaTemp = new PersonaJuridica();
//        return "asociarACliente";
//    }
    public String AsociarTitular() {
        //detalleCuentaCliente = new DetalleCuentaCliente();
        personaNaturalTemp = new PersonaNatural();
        personaJuridicaTemp = new PersonaJuridica();
        // bolAgregarCliente = true; //nos servira para tener la opcion "Agregar Cliente" cuando vayamos
        //al la pagina "ListarCliente"
        return "asociarACliente";
    }

    public String AsociarACuenta() {
//        personasJuridicasAgregar = new ArrayList<PersonaJuridica>();
//        personasNaturalesAgregar = new ArrayList<PersonaNatural>();
        //para que no pueda aparecer la opcion de Guardar, cuando viene de un "Nueva CUenta"
        bolAgregarPersonaJuridica = false;
        bolAgregarPersonaNatural = false;
        return "asociarACuenta";
    }

    public String TarjetaPendiente() {
        return "editar";
    }

    public String AceptarAsociacionNatural() {//cuando aceptamos guardar la asociacion desde Lista Cuentas
        try {
            for (PersonaNatural pn : personasNaturalesAgregar) {
//seteamos primero la entidad "DetalleCuentaClientePK"
                detalleCuentaClientePK.setFidSegPersona(pn.getIdPersona());
                detalleCuentaClientePK.setFidPltCuenta(cuenta.getIdCuenta());
//seteamos el PK embebido en el nuevo objeto que voy a persistir
                detalleCuentaCliente.setDetalleCuentaClientePK(detalleCuentaClientePK);
//persistimos el nuevo objeto

                detalleCuentaClienteDelegado.crear(detalleCuentaCliente);
            }
            //Le cambiamos el estado a la Cuenta a "TitularAsociado"
            cuenta.setEstadoCuenta(EstadoCuenta.Aperturado);
            cuentaDelegado.editar(cuenta);
            personasNaturalesAgregar = new ArrayList<PersonaNatural>();
            //------------------------------------------------------
            //reiniciarEstados();
            //  modalidadAfiliacion = ModalidadAfiliacion.Individual;//vuelve por defecto para que siempre lo encontremos en individual
            info("La Asociacion se realzó correctamente");
        } catch (Exception e) {
            error("No se pudo asociar");
        }
        return "cuentaAsociada";//me regrese a la pagina donde estaba registrando A la lista de cuentas
    }

    public String AceptarAsociacionNatural1() {//cuando aceptamos guardar la asociacion desde Nueva Cuenta
        personasNaturalesAgregar = new ArrayList<PersonaNatural>();
        // reiniciarEstados();
        return "asociarClienteANuevo";//me regrese a la pagina donde estaba registrando A la lista de cuentas
    }

    public String AceptarAsociacionJuridica() {//cuando aceptamos guardar la asociacion
        try {//seteamos el detallePK
            detalleCuentaClientePK.setFidSegPersona(personaJuridicaTemp.getIdPersona());
            detalleCuentaClientePK.setFidPltCuenta(cuenta.getIdCuenta());

            //le pasamos la relacion "idembebido"
            detalleCuentaCliente.setDetalleCuentaClientePK(detalleCuentaClientePK);
            detalleCuentaClienteDelegado.crear(detalleCuentaCliente);
            detalleCuentaCliente.setFechaAfiliacion(new java.sql.Date(getFechaActual().getYear(), getFechaActual().getMonth(), getFechaActual().getDay() + 1));
            //Le cambiamos el estado a la Cuenta a "TitularAsociado"
            cuenta.setEstadoCuenta(EstadoCuenta.TitularAsociado);
            cuentaDelegado.editar(cuenta);
            //------------------------------------------------------
            //   reiniciarEstados();
            //modalidadAfiliacion = ModalidadAfiliacion.Individual;//vuelve por defecto para que siempre lo encontremos en individual
            personasJuridicasAgregar = new ArrayList<PersonaJuridica>();
            info("La Asociacion se realzó correctamente");
        } catch (Exception e) {
            error("No se pudo asociar");
        }
        return "cuentaAsociada";//me regrese a la pagina donde estaba registrando la cuenta
    }

    public String AceptarAsociacionJuridica1() {//cuando aceptamos guardar la asociacion

        //    reiniciarEstados();
        return "asociarClienteANuevo";//me regrese a la pagina donde estaba registrando A la lista de cuentas
    }

//    public SelectItem[] getModalidadesAfiliacion() {
//        ModalidadAfiliacion[] modalidadesAfilicacion = ModalidadAfiliacion.values();
//        SelectItem[] select = new SelectItem[modalidadesAfilicacion.length];
//        int i = 0;
//        // ModalidadAfiliacion modalidadTemp = ModalidadAfiliacion.Individual;
//        for (ModalidadAfiliacion ma : modalidadesAfilicacion) {
//            select[i++] = new SelectItem(ma, ma.toString());//se completa el cuadro normalmente
//        }
//        return select;
//    }
    //------------------------------------------------------------
    public String reiniciarEstados() {
//        bolAgregarPersonaJuridica = true;
//        bolAgregarPersonaNatural = true;
        bolAgregarCliente = false;
        bolAgregarPersonaNatural =false;
        bolAgregarPersonaJuridica = false;
        bolInicioTablaAgregarPersonas = false;
        bolEditarMancomunados = false;
        //Tambien algunos obejtos de trabajo
        personasJuridicasAgregar = new ArrayList<PersonaJuridica>();
        personasNaturalesAgregar = new ArrayList<PersonaNatural>();
        nuevosMancomunadosAgregar = new ArrayList<PersonaNatural>();
        personaJuridicaTemp = new PersonaJuridica();
        personaNaturalTemp = new PersonaNatural();
        cuenta = null;
        return "";
    }

    //------------------------------------------UC:ACTUALIZAR MANCOMUNADO
//de cuenta/editar.jsp -> cuenta/cuenta/asociarCuentaPersona.jsp
    public String actualizarMancomunados() {
        reiniciarEstados();
        bolEditarMancomunados = true;
        bolAgregarPersonaJuridica = false;
        bolAgregarPersonaNatural = false;
        //vamos a obtener el cuentaController, para poder
        //trabajar con varios objetos
        personasNaturalesAgregar = cuentaControllerTemp.getPersonasNaturalesAgregar();
        cuenta = cuentaControllerTemp.getCuenta();
        //modalidadCuenta = cuentaControllerTemp.buscarModalidadAfiliacionPorNumeroCuenta(cuenta.getIdCuenta());
        //nuevosMancomunadosAgregar = new ArrayList<PersonaNatural>();
        //bolInicioTablaAgregarPersonas = true;
        return "actualizarMancomunado";
    }

    //de cuenta/cuenta/asociarCuentaPersona.jsp -> cuenta/editar.jsp
    public String guardarNuevosMancomunados() {
        //vamos a unir las listas solo para mostrarlos en cuenta/editar
        //por que luego se encuentran en listas distintas
        //cuentaControllerTemp.getPersonasNaturalesAgregar().addAll(nuevosMancomunadosAgregar);
        if ((personasNaturalesAgregar.size() == 0) && (nuevosMancomunadosAgregar.size() == 0)) {
            error("No puede dejar sin titulares a esta Cuenta, Seleccione un Titular");
        }
        return "guardarMancomunados";
    }

    public String cancelarEditarMancomunados() {
        reiniciarEstados();
        return "guardarMancomunados";
    }

    public String agregarMancomunado() {
        //nuevosMancomunadosAgregar = new ArrayList<PersonaNatural>();
        personaNaturalTemp = new PersonaNatural();
        bolAgregarPersonaNatural = false;//para permitir agregar persona natural al momento de listarlo
        bolEditarMancomunados = true;
        // bolAgregarCliente = true; //nos servira para tener la opcion "Agregar Cliente" cuando vayamos
        //al la pagina "ListarCliente"
        return "asociarACliente";
    }
//de mostrar -> asociarCuentaPersona

    public String mancomunadoRetirado() {
        //hace una busqeuda por los mancomunados agregados
        for (PersonaNatural pn : personasNaturalesAgregar) {
            if (pn.getIdPersona() == personaNaturalTemp.getIdPersona()) {
                personasNaturalesAgregar.remove(pn);
                return "clienteRetirado";
            }
        }
        //hace una busqeuda por los mancomunados nuevos
        for (PersonaNatural pn : nuevosMancomunadosAgregar) {
            if (pn.getIdPersona() == personaNaturalTemp.getIdPersona()) {
                nuevosMancomunadosAgregar.remove(pn);
                return "clienteRetirado";
            }
        }
        return "clienteRetirado";
    }
//de mostrar -> asociarCuentaPersona

    public String CancelarMancomunado() {
        return "clienteRetirado";
    }
// de asociarCuentaPersona -> mostrar , para poder eliminar el mancomunado seleccionado

    public String mancomunadoARetirar() {
        bolAgregarPersonaNatural = false;//para deshabilitar la opcion de eliminar un cliente natural
        return "clienteARetirar";
    }
    //de cuenta/editar -> cuenta/listar, para aceptar la atualizacion de mancomunados

    public String actualizar() {
        long idCuenta;
        if (cuenta.getIdCuenta() != null) {
            idCuenta = cuenta.getIdCuenta();
        } else {
            return "listar";//Para cuando presionen el boton Aceptar en la opcion Editar
        }

        DetalleCuentaCliente detalleCuentaClienteTemp = new DetalleCuentaCliente();
        List<PersonaNatural> mancomunadosADesactivar = new ArrayList<PersonaNatural>();
        try {
            //vamos a obtener la lista original de mancomunados de la cuenta
            mancomunadosADesactivar = cuentaDelegado.buscarPersonasNaturalesPorNroCuenta(cuenta.getNroCuenta());
        } catch (Exception e) {
            error("Error al cargar los mancomunados de la Cuenta");
        }
        //List<Integer> indices = new ArrayList<Integer>();
//        for (PersonaNatural pn : mancomunadosADesactivar) {
//            for (PersonaNatural pn1 : personasNaturalesAgregar) {
//                //empezamos a bucar a cada uno de los mancomunados sobrevivientes
//                //dentro de la lista original para cambiarle el estado
//                if (pn.getIdPersona() == pn1.getIdPersona()) {
//                    //si no se encuenta en la lista de mancomunados originales es por que fue eliminado
//                    //asi los que van coincidiendo los sacamos de la lista para luego eliminar la lista que queda
//
//                    mancomunadosADesactivar.remove(pn);
//                }
//            }
//        }

        for (PersonaNatural pn1 : personasNaturalesAgregar) {
            mancomunadosADesactivar.remove(pn1);
        }

        //actualizamos el estado como NOASOCIADO a los mancomunados eliminados
        for (PersonaNatural pn : mancomunadosADesactivar) {
            try {
                detalleCuentaClienteTemp = cuentaDelegado.buscarAsociacionPorClienteYCuenta(idCuenta, pn.getIdPersona());
                detalleCuentaClienteTemp.setEstadoDetalleCuentaCliente(EstadoDetalleCuenta.NoAsociado);
                detalleCuentaClienteDelegado.editar(detalleCuentaClienteTemp); //guardamos el detalle actualizado
            } catch (Exception e) {
            }
        }
        //pasamos a guardar a los mancomunados nuevos
        for (PersonaNatural pn : nuevosMancomunadosAgregar) {
            detalleCuentaClienteTemp = new DetalleCuentaCliente();
            try {
                if (personasNaturalesAgregar.size() + nuevosMancomunadosAgregar.size() > 1) {
                    detalleCuentaClienteTemp.setModalidadAfiliacion(ModalidadAfiliacion.MancomunadoConjunta);//paa cualquier pueda retirar
                }
                detalleCuentaClientePK.setFidPltCuenta(idCuenta);
                detalleCuentaClientePK.setFidSegPersona(pn.getIdPersona());
                detalleCuentaClienteTemp.setDetalleCuentaClientePK(detalleCuentaClientePK);
                detalleCuentaClienteTemp.setEstadoDetalleCuentaCliente(EstadoDetalleCuenta.Asociado);
                detalleCuentaClienteDelegado.crear(detalleCuentaClienteTemp);
            } catch (Exception e) {
            }
        }
        CuentaController tempcontroller = (CuentaController) getBean("CuentaController");
        if (tempcontroller != null) {
            //para evitar opciones de "agregarCLiente" en el Tarjeta/listar.jsp
            tempcontroller.cuenta = null;
        }
        reiniciarEstados();//limpiamos todo
        return "listar";
    }

    public String getModalidadCuenta() {
        String modalidad = "";
        try {
            modalidad = cuentaDelegado.buscarModalidadAfiliacionPorNumeroCuenta(cuenta.getIdCuenta());
        } catch (Exception e) {
        }
        return modalidad;
    }
//--------------------------------------------------------------VARIOS

    public Date getFechaActual() {
        return new Date();
    }

    public boolean isBolAgregarPersonaJuridica() {
        return bolAgregarPersonaJuridica;
    }

    public void setBolAgregarPersonaJuridica(boolean bolAgregarPersonaJuridica) {
        this.bolAgregarPersonaJuridica = bolAgregarPersonaJuridica;
    }

    public boolean isBolAgregarPersonaNatural() {
        return bolAgregarPersonaNatural;
    }

    public void setBolAgregarPersonaNatural(boolean bolAgregarPersonaNatural) {
        this.bolAgregarPersonaNatural = bolAgregarPersonaNatural;
    }

    public Cuenta getCuenta() {
        return cuenta;
    }

    public void setCuenta(Cuenta cuenta) {
        this.cuenta = cuenta;
    }

    public DetalleCuentaCliente getDetalleCuentaCliente() {
        return detalleCuentaCliente;
    }

    public void setDetalleCuentaCliente(DetalleCuentaCliente detalleCuentaCliente) {
        this.detalleCuentaCliente = detalleCuentaCliente;
    }

    public DetalleCuentaClientePK getDetalleCuentaClientePK() {
        return detalleCuentaClientePK;
    }

    public void setDetalleCuentaClientePK(DetalleCuentaClientePK detalleCuentaClientePK) {
        this.detalleCuentaClientePK = detalleCuentaClientePK;
    }

    public Persona getPersonaTemp() {
        return personaTemp;
    }

    public void setPersonaTemp(Persona persona) {
        this.personaTemp = persona;
    }

//    public PersonaJuridica getPersonaJuridica() {
//        return personaJuridica;
//    }
//
//    public void setPersonaJuridica(PersonaJuridica personaJuridica) {
//        this.personaJuridica = personaJuridica;
//    }
    public PersonaNatural getPersonaNaturalTemp() {
        return personaNaturalTemp;
    }

    public void setPersonaNaturalTemp(PersonaNatural personaNaturalTemp) {
        this.personaNaturalTemp = personaNaturalTemp;
    }

    public PersonaJuridica getPersonaJuridicaTemp() {
        return personaJuridicaTemp;
    }

    public void setPersonaJuridicaTemp(PersonaJuridica personaJuridicaTemp) {
        this.personaJuridicaTemp = personaJuridicaTemp;
    }

    public boolean isBolAgregarCliente() {
        return bolAgregarCliente;
    }

    public void setBolAgregarCliente(boolean bolAgregarCliente) {
        this.bolAgregarCliente = bolAgregarCliente;
    }

    public List<PersonaJuridica> getPersonasJuridicasAgregar() {
        return personasJuridicasAgregar;
    }

    public void setPersonasJuridicasAgregar(List<PersonaJuridica> personasJuridicasAgregar) {
        this.personasJuridicasAgregar = personasJuridicasAgregar;
    }

    public List<PersonaNatural> getPersonasNaturalesAgregar() {
        return personasNaturalesAgregar;
    }

    public void setPersonasNaturalesAgregar(List<PersonaNatural> personasNaturalesAgregar) {
        this.personasNaturalesAgregar = personasNaturalesAgregar;
    }

    public boolean isEsClienteNatural() {
        return esClienteNatural;
    }

    public void setEsClienteNatural(boolean esClienteNatural) {
        this.esClienteNatural = esClienteNatural;
    }

    public boolean isBolInicioTablaAgregarPersonas() {
        return bolInicioTablaAgregarPersonas;
    }

    public void setBolInicioTablaAgregarPersonas(boolean bolInicioTablaAgregarPersonas) {
        this.bolInicioTablaAgregarPersonas = bolInicioTablaAgregarPersonas;
    }

    public boolean isBolEditarMancomunados() {
        return bolEditarMancomunados;
    }

    public void setBolEditarMancomunados(boolean bolEditarMancomunados) {
        this.bolEditarMancomunados = bolEditarMancomunados;
    }

    public List<PersonaNatural> getNuevosMancomunadosAgregar() {
        return nuevosMancomunadosAgregar;
    }

    public void setNuevosMancomunadosAgregar(List<PersonaNatural> nuevosMancomunadosAgregar) {
        this.nuevosMancomunadosAgregar = nuevosMancomunadosAgregar;
    }

    public CuentaController getCuentaControllerTemp() {
        return cuentaControllerTemp;
    }

    public void setCuentaControllerTemp(CuentaController cuentaControllerTemp) {
        this.cuentaControllerTemp = cuentaControllerTemp;
    }
//    public Date getFechaActual() {
//        return fechaActual;
//    }
//
//    public void setFechaActual(Date fechaActual) {
//        this.fechaActual = fechaActual;
//    }
//    public String getModalidadCuenta() {
//        return modalidadCuenta;
//    }
//
//    public void setModalidadCuenta(String modalidadCuenta) {
//        this.modalidadCuenta = modalidadCuenta;
//    }
//    public ModalidadAfiliacion getModalidadAfiliacion() {
//        return modalidadAfiliacion;
//    }
//
//    public void setModalidadAfiliacion(ModalidadAfiliacion modalidadAfiliacion) {
//        this.modalidadAfiliacion = modalidadAfiliacion;
//    }
}
